Optimized client-side deduplication

ABSTRACT

One example method includes optimizing client-side deduplication. When backing up a client, an overwrite ratio is determined based on a size of actual changes made to a volume and a size indicated by changes in a change log. Client-side deduplication is enabled or disabled based on a value of the overwrite ratio.

FIELD OF THE INVENTION

Embodiments of the present invention generally relate to data protection operations. More particularly, at least some embodiments of the invention relate to systems, hardware, software, computer-readable media, and methods for data protection operations including deduplication operations.

BACKGROUND

Data protection operations are performed to protect data and ensure that, in the event of corruption, loss, or other event, data can be restored. Protecting data, however, continues to present new challenges. For example, the size of data to be protected in continually increasing. Further, there are many ways in which in user may protect their data. A user may decide, for example, between continuous backup operations, periodic backups, and the like. These decisions are further complicated by the computing environments in which data is stored and the environments in which backups may be stored. As a result, data protection operations can be complicated and complex.

As previously stated, decisions regarding data protection operations are no longer driven by a few factors such as the size of the data being protected. It is necessary to consider other factors such as bandwidth, deduplication, encryption, and type of backup. There is a need to identify ways to improve various aspects of data protection operations.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which at least some of the advantages and features of the invention may be obtained, a more particular description of embodiments of the invention will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, embodiments of the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings, in which:

FIG. 1 discloses aspects of a computing environment including a data protection system configured to perform data protection operations including client-side deduplication operations;

FIG. 2 discloses aspects of a change log for tracking changes to a storage such as a volume;

FIG. 3 discloses aspects of determining an overwrite ratio based on actual data and a bitmap data size;

FIG. 4 discloses aspects of determining an overwrite ratio where deduplication is not enabled;

FIG. 5 discloses aspects of a filter configured to participate in determining an overwrite ratio in a backup operation;

FIG. 6 discloses aspects of a data protection operation that includes determining an overwrite ratio; and

FIG. 7 discloses aspects of a computing system in which data protection operations may be implemented.

DETAILED DESCRIPTION OF SOME EXAMPLE EMBODIMENTS

Embodiments of the present invention generally relate to data protection operations. More particularly, at least some embodiments of the invention relate to systems, hardware, software, computer-readable media, and methods for data protection operations including backup operations and deduplication operations.

Backup operations and deduplication operations are examples of data protection operations and deduplication operations are often performed in the context of backup operations. Deduplication can be performed at the source or client side of a backup operation or at a target or server side of the backup operation.

Embodiments of the invention operate to determine an overwrite ratio. The overwrite ratio relates, by way of example only, to a ratio between data written to extents in a volume and the total size of those extents. By way of example, an extent corresponds to a portion of the volume. The size of the extent depends on the number of entries in a change log (used to track which extents have been changed since a most recent backup). Thus, the extent size may depend on the volume size. For example, a change log with 2 million entries results in an extent size of 500 KB for a 1 TB volume (size of volume divided by number of entries in the change log). Embodiments of the invention enable/disable client-side deduplication based on the amount of data written to the volume and the size represented by the impacted extents. This overwrite ratio is indicative of how well the extents will deduplicate as discussed in more detail below. In other words, a large amount of overwrite may be associated with poor deduplication while a smaller amount of overwrite may be associated with good deduplication. Deduplication is thus enabled/disabled based on the overwrite ratio.

FIG. 1 discloses aspects of a data protection operation. FIG. 1 illustrates a production site 150 and a target site 152. Generally, data and/or applications operating at the production site 150 are backed up at the target site 152. The backup operation may include backup operations such as replication operations, mirroring operations, incremental backup operations, journal-based backup operations, or the like. The production site 150 and/or the target site 152 may be on-site systems, cloud-based systems, and may use virtual machines, physical machines, containers, or the like or combination thereof.

At the production site 150, an appliance 104, which may represent multiple appliances, may be installed and may operate as a physical machine, a virtual machine, a container, or the like. The server 108 may similarly be physical, virtual, container based, or the like. The appliance 104 may also represent a data protection system, which may include one or more devices, software components, or the like.

Generally, the appliance 104 is configured to protect applications and/or data stored at the source storage 102 by creating a backup of data on the source storage 102 (e.g., a copy of the applications and/or data) to the target site 152. At the target site 152, the server 108 may commit the backup to the target storage. The storage 102 and 110 may include virtual volumes or disks, physical volumes or disks, or other storage devices and arrangements.

To improve the efficiency of a backup operation, the appliance 104 may perform operations such as deduplication 120. The server 108 may also perform deduplication 122. Deduplication can improve a backup operation, by way of example, by reducing the amount of data transferred over the network 106 and by reducing storage requirements at the target site 152.

In general, deduplication is performed by chunking the data into chunks. Each chunk usually has the same size, although variable sized chunking may be employed. Next a hash is generated for each chunk and stored. The hash is a unique representation of the chunk. The chunk size may vary. An example chunk size is 8 KB, but the chunk may be smaller or larger. Changing the chunk size may impact efficiencies. For example, large chunk sizes may not deduplicate as efficiently as smaller chunk sizes. Deduplicating using smaller chunk sizes, on the other hand, may consume processing resources.

When deduplicating, the appliance 104 may generate a hash of a chunk and then transmit the hash to the server 108 to determine if the chunk already exists on the target storage 110. Because the server 108 maintains metadata identifying a list of chunks stored in the target storage 110 and the corresponding hashes or identifiers of the chunks, the server 108 can inform the appliance 104 whether the chunk is already present at the target site 152. When the chunk is already present, metadata related to the chunk can be transferred instead of the chunk itself. This eliminates the need to transfer the chunk over the network 106. However, if the chunk is not present at the target site 152, it is necessary to transmit the chunk itself to perform the backup operation.

Performing deduplication 120 at the production site 150 can consume resources including processor resources and memory resources. When transferring larger amounts of data (e.g., an initial or genesis backup such as a full backup), it is possible that performing deduplication can improve performance. When transferring a smaller amount of data (e.g., an incremental backup), performing deduplication may adversely impact performance.

Embodiments of the invention relate to determining when to perform deduplication 120 and when to not perform deduplication 120. The appliance 104 may be configured to determine when to perform deduplication 120 and when to cease deduplication 120.

More specifically, deduplication is based on hashing data and using the hash to find copies of the data. Storing the hash instead of the full data allows reduction in storage requirements for duplicate occurrences of that data. Client-side deduplication allows communication (e.g., the amount of data transferred) between a data source (e.g., the source storage 102) and a deduplication target (e.g., the target storage 110) to be optimized.

As previously stated, the client calculates a hash of data (e.g., of a chunk) and then sends the hash to the target. If the hash already exists on the target, there is no need to send the chunk itself. Otherwise, the full chunk is sent to the target site 152.

The tradeoff is processing resources on the client or production side (e.g., to calculate the hash) and, potentially, two round trip communications if the hash does not exist at the target site 152. If the hash does exist, bandwidth is used more efficiently and processing is reduced at the target site 152.

In one example, a flag 130 is used to determine whether or not the appliance 104 performs deduplication 120. If the flag 130 is set, deduplication is performed when opening a backup stream to the target site 152. When the flag 130 is not set or is disabled, data is sent without performing deduplication 120.

In some embodiments, the decision to set or not set the flag 130 (or the decision to perform or not perform deduplication) is based on an overwrite ratio. The overwrite ratio generally compares the amount of data actually written to the source storage 102, such as a volume, with the size of the data in the volume impacted by the writes. More specifically and as discussed in more detail below, a volume may be represented by a bitmap. Each entry in the bitmap corresponds to a part of the volume (e.g., an extent). Entries in the bitmap are generated when data is written to a corresponding location in the volume. However, the actual data written is not always the same size as the extent. The overwrite ratio is a way to compare the amount of data actually written with the size of the volume portions or extents marked as dirty in the bitmap.

If the overwrite ratio at the client or production side is high, most IOs will incur two round trips (one for the hash and one for the data if the hash is not present at the target) and lower the performance of the data protection operations. In effect, the benefit gained from performing deduplication is less than the cost of the processing and memory resources consumed by the deduplication operations. When the overwrite ratio is low, this suggests that deduplication will provide benefits. Thus, data that can be deduplicated is not transferred and bandwidth is saved. Conventionally, the actual overwrite ratio can only be determined after the fact. Embodiments of the invention approximate the overwrite ratio and then performs or does not perform deduplication 120 on the client or production side.

Before discussing aspects of determining or approximating the overwrite ratio, an example of a change block tracking (CBT) bitmap is discussed. Thus, the CBT bitmap is an example of a change log. CBT is an algorithm used to track areas of a disk or volume (e.g., VMDK) that have changed since a previous backup or point in time. Each volume may be associated with a CBT bitmap. FIG. 2 illustrates an example of a simplistic bitmap. FIG. 2 illustrates a bitmap 200 in an initialized state and illustrates the same bitmap 202 after at least one IO since being initialized or reset. The bitmap 202 represents the bitmap 200 at a different point in time.

In one example, each bit in the CBT bitmap represents a fixed size extent (e.g., 64 KB) and the index of the bit correlates to a location on the volume. Thus, bit 0 (0 is the index) corresponds to a first location on a volume or, when the extent size is 64 KB, to the first 64K block on the volume and bit 1 represents the next 64K block on the volume. In this example each bit in the map 200 has a value of 0. Thus, the bitmap 200 is initialized or has been reset.

When an IO is performed at a location on the volume, the bits that correspond to that location are set to 1. A write may impact more than one bit in the CBT bitmap as illustrated in the map 202. Any overlap between the IO and the extent causes the corresponding bit to be set. Thus, a write of 72K to location 0 also impacts location 1. Thus, bit 0 and bit 1 are set to 1 as illustrated in the map 202 even though only 8K of the extent or block associated with bit 1 is impacted by the write. At this stage, the remaining bits in the map 202 are still 0.

In one example, the CBT bitmap is fixed in size. A bitmap of 256 KB provides for 2 million bits. However, the extent size per bit increases as the disk size increases. Generally, the granularity (extent size) is somewhere between 8 KB and 128 KB. However, the extent size may be much larger when the corresponding volume sizes are larger. A 64 TB disk, for example, is associated with 32 MB extents. In another example, the CBT bitmap size is variable. By way of example and not limitation, the granularity may be between 8 KB and 128 KB (or smaller or larger). The size of the extent may also impact performance.

When performing, for example, an incremental backup, the CBT bitmap is used to identify which of the extents on the volume have changed and are, as a result, copied to the target site. Only the extents at locations corresponding to set bits in the CBT bitmap need to be transferred during an incremental backup. Thus, if a backup operation is performed based on the bitmap 202, only the blocks at locations 0 and 1 are transferred. After the backup, the bitmap is reset (or a new bitmap is used) such that all values are 0 in the bitmap.

In one example, the flag 130 is determined each time a backup stream is opened or each time a backup operation is performed. For a generation 0 backup (e.g., an initial backup), the flag may be set because a full backup is likely to benefit from deduplication 120. Differential or incremental backups may not benefit from deduplication 120 and the flag 130 may be set to off.

When determining whether to perform deduplication, the actual data size may be determined. The actual data size corresponds to the amount of data written since the bitmap was reset or since the most recent backup in one example. In one example, an actual data size is determined by adding a small counter in the IO path. When the bitmap is reset, the actual data size is set to 0 (zero). Each time a write passes through the IO stack, the actual data size is redetermined as follows: actual data size=actual data size+IO size.

Some IO stacks may track the size (Native Actual Data Size). However, the size relative to the bitmap status may still be needed. In this case, when the bitmap is reset, start native actual data size=native actual data size.

When the overwrite ratio is evaluated, actual data size=native actual data size−start native actual data size.

In either case, the actual data size can be determined and may be determined relative to resetting the bitmap used to track changed blocks.

Next, a bitmap data size is determined. The bitmap data size is the size of the dirty areas covered by the bitmap. The bitmap data size is: bitmap data size=number of dirty bits*extent size

FIG. 3 discloses aspects of determining an overwrite ratio and determining whether to perform client-side deduplication. FIG. 3 illustrates a bitmap 300. In this example, the bitmap has 8 entries and bits 304, 306, and 308 are set to 1. Thus, the blocks or extents on the volume 302 corresponding to the bits 304, 306, and 308 have experienced IO or writes since the last time the bitmap 300 was reset. In some examples, resetting bitmap may include generating a new bitmap such that the old bitmap may be used to process entries that are dirty (that correspond to or identify extents or blocks that have experienced IOs).

In the volume 302, the dark grey corresponds to data written, light gray corresponds to previously existing data, and unshaded boxes have not been written to since the bitmap 300 was reset. Thus, the bits 304, 306, and 308 identify dirty extents.

By way of example and not limitation, the extent 324 on the volume 302 includes a changed portion 310 and a clean or unchanged portion 312. In this example, the size of the extent 324 may be 64 KB. The size of the changed portion 310 is 16 KB and the size of the unchanged portion 312 is 48 KB. Similarly, the extent 326 includes changed portions 314 and 318 and unchanged portions 316 and 320. The size of the changed portions 314 and 318 is (10 KB+10 KB or 20 KB) and the size of the unchanged portions 316 and 320 is 44 KB. The entire extent 328 is changed. Thus, the size of the changed portion 322 is 64 KB and the size of the unchanged portion is 0 KB for the extent 328. cc

Regardless of how much data is written to an extent, any change results in the corresponding bitmap entry being set to 1. Thus, the bits 304, 306, and 308 are each set to 1.

In the case of FIG. 3 , the bitmap data size is 192 KB=3*64 KB as there are three set bits in the bitmap 300. The actual data size can vary. At a minimum, the actual data size is 16 KB+10 KB+10 KB+64 KB=100 KB. However, the actual data size can vary because the changed portions 310, 314, 318, and 322 may have been written to multiple times.

Because the same portion of an extent may be written to multiple times, an overwrite factor may be introduced to quantify the overwrite. The overwrite pattern is workload specific, but is typically 25% to 30%. The value of 30% can be used to provide better overwrite ratios. Other values may be selected based on experience or based on overwrite patterns. It may be possible to track the sizes or writes and the locations. This may eliminate the need to use an overwrite factor by simply tracking the size of extent portions that are actually overwritten. However, this may also impact performance.

The overwrite ratio is determined as follows:

${{overwrite}{ratio}} = \frac{{{actual}{data}{size}} \star \frac{\left( {100 - {{overwrite}{factor}}} \right)}{100}}{{bitmap}{data}{size}}$

In this example, and assuming that the actual data size is 120 KB, the overwrite ratio is:

${{overwrite}{ratio}} = {\frac{120 \star \frac{\left( {100 - 30} \right)}{100}}{192} = \text{.4375}}$

If the overwrite ratio is 1, everything is substantially covered (dark grey for the affected extents in FIG. 3 ) and no deduplication is likely. In other words, the extents contain essentially new data that has not been previously backed up. The lower the value of the overwrite ratio, the higher the probability of finding chunks that can be deduplicated. The lower the value of the overwrite ratio, the more light gray in FIG. 3 .

A threshold value may be set. If the overwrite ratio is less than the threshold value or threshold ratio, the deduplication flag is enabled and client side deduplication is performed. An example threshold value is 0.7. In this example, 0.4375 is less than 0.7. As a result, the client-side deduplication is enabled. If the overwrite ratio is higher than the threshold, client-side deduplication may be disabled.

FIG. 4 illustrates an example where little deduplication is expected and deduplication is disabled. FIG. 4 is similar to FIG. 3 , but illustrates that the extents associated with the changed bits are completely changed. This results in a situation where the overwrite ratio is higher than the threshold value. As a result, the flag 130 is off and client-side deduplication is disabled in the scenario of FIG. 4 .

In some embodiments, the resolution of the tracking bitmap or change log (e.g., bitmap 300) is different from the deduplication resolution. For example, the bitmap 300 may use a bit for each 64 KB extent on a volume. Thus, the bitmap resolution is 64 KB. The deduplication resolution, in contrast, may be smaller such as 8 KB. The overwrite ratio helps identify when the differences in the resolution may result in a performance improvement.

For example, if the bitmap resolution is 1 MB and a single 8 KB write occurred to an extent, the entire 1 MB extent is marked as dirty in the bitmap. When deduplicating on 8 KB sized chunks, this suggests that 99% of the extent can be deduplicated. In contrast, if the bitmap resolution is 64 KB and a single 8 KB write occurred, this suggests that about 88% of the extent can be deduplicated. If the write was for 32 KB, then only about 50% of the 64 KB extent can be deduplicated. Embodiments of the invention, by determining the overwrite ratio and setting a threshold, can define a decision point for determining when to enable client-side deduplication and when to disable client-side deduplication. The threshold could be tuned over time based on experimental data, using machine learning, or the like.

Embodiments of the invention further operate with multiple types of backups including snapshot based backups and light weight delta (LWD) based backups in physical and virtual environments. FIG. 5 illustrates a computing system in which snapshots, such as LWD snapshots, are created. The system 500 may include a virtual machine 520 that may be associated with a VMDK, such as volume 506. A filter 504 is implemented in the IO path between the virtual machine 502 and the volume 506.

The filter 504 may operate to help determine actual data size for use in determining the overwrite ratio. This information may be provided to the appliance 508. In addition, in LWD, for example, IOs may be marked in a bitmap (included in the bitmaps 51) by the filter 504 that may be present in, by way of example, the IO stack. When a snapshot is requested, a new bitmap (e.g., a new CBT bitmap) is created in the bitmaps 510 and the appliance 508 may begin processing the previous bitmap, which identifies which areas of the volume 506 are dirty or have experienced changes that need to be backed up. The dirty bits are processed and the corresponding data from the volume 506 is processed by the appliance 508. To process the data, the overwrite ratio may be determined and deduplication is then performed or not performed based on the value of the overwrite ratio.

If a new IO is received for a dirty area that has not been processed or read, the new bitmap is marked, the data is read from the volume 506 by the filter 504 and stored in a demand log, which may be present in the bitmaps 510. This allows the snapshot to be created with minimal impact on the virtual machine 502 and/or the volume 506. A snapshot can be created without quiescing the virtual machine 502. When all of the dirty bits from the previous bitmap have been processed, the snapshot/deduplication is completed using the demand log. The demand log may then be deleted.

FIG. 6 discloses aspects of a method for performing data protection operation and, in particular, for performing a deduplication operation that may be part of a backup operation. In the method 600, a backup operation may be initiated 602. The backup operation may be initiated by opening a backup stream, taking a snapshot, or the like or combination thereof. Next, an overwrite ratio is determined 604. The overwrite ratio is based on the data actually written to a volume (or other storage) and based on the data represented by dirty bits in a change log (e.g., a CBT bitmap). The ratio may be adjusted to account for portions of the volume that were overwritten more than once.

Determining 604 the overwrite ratio may include installing a filter in the IO path of the computing system. This filter allows the actual data size, relative to a current backup, to be determined.

Client-side deduplication is then enabled or disabled 606 based on the overwrite ratio. If the overwrite ratio is higher than (or equal to) a threshold, by way of example, deduplication is disabled on the client-side. If the overwrite ratio is lower than the threshold, then deduplication is enabled on the client-side.

Next, the backup operation is performed 608. This may include transferring data to a remote site, or the like.

When performing deduplication, each of the extents associated with a dirty or set bit in the bitmap may be chunked into small sized chunks for deduplication purposes. Further, the data may be backed up in terms of chunks such that, when reconstructing or recovering data, the data is reconstructed or recovered from the deduplicated chunks stored at the target site.

The following is a discussion of aspects of example operating environments for various embodiments of the invention. This discussion is not intended to limit the scope of the invention, or the applicability of the embodiments, in any way.

In general, embodiments of the invention may be implemented in connection with systems, software, and components, that individually and/or collectively implement, and/or cause the implementation of, data protection operations which may include, but are not limited to, data replication operations, IO replication operations, data read/write/delete operations, data deduplication operations, data backup operations, data restore operations, data cloning operations, data archiving operations, and disaster recovery operations. More generally, the scope of the invention embraces any operating environment in which the disclosed concepts may be useful.

In general however, the scope of the invention is not limited to any particular data backup platform or data storage environment.

New and/or modified data collected and/or generated in connection with some embodiments, may be stored in a data protection environment that may take the form of a public or private cloud storage environment, an on-premises storage environment, and hybrid storage environments that include public and private elements. Any of these example storage environments, may be partly, or completely, virtualized. The storage environment may comprise, or consist of, a datacenter which is operable to service read, write, delete, backup, restore, and/or cloning, operations initiated by one or more clients or other elements of the operating environment. Where a backup comprises groups of data with different respective characteristics, that data may be allocated, and stored, to different respective targets in the storage environment, where the targets each correspond to a data group having one or more particular characteristics.

Example cloud computing environments, which may or may not be public, include storage environments that may provide data protection functionality for one or more clients. Another example of a cloud computing environment is one in which processing, data protection, and other, services may be performed on behalf of one or more clients. Some example cloud computing environments in connection with which embodiments of the invention may be employed include, but are not limited to, Microsoft Azure, Amazon AWS, Dell EMC Cloud Storage Services, and Google Cloud. More generally however, the scope of the invention is not limited to employment of any particular type or implementation of cloud computing environment.

In addition to the cloud environment, the operating environment may also include one or more clients that are capable of collecting, modifying, and creating, data. As such, a particular client may employ, or otherwise be associated with, one or more instances of each of one or more applications that perform such operations with respect to data. Such clients may comprise physical machines, or virtual machines (VM), or containers.

Particularly, devices in the operating environment may take the form of software, physical machines, or VMs, containers, or any combination of these, though no particular device implementation or configuration is required for any embodiment. Similarly, data protection system components such as databases, storage servers, storage volumes (LUNs), storage disks, replication services, backup servers, restore servers, backup clients, and restore clients, for example, may likewise take the form of software, physical machines or virtual machines (VM) or containers, though no particular component implementation is required for any embodiment.

As used herein, the term ‘data’ is intended to be broad in scope. Thus, that term embraces, by way of example and not limitation, data segments such as may be produced by data stream segmentation processes, data chunks, data blocks, atomic data, emails, objects of any type, files of any type including media files, word processing files, spreadsheet files, and database files, as well as contacts, directories, sub-directories, volumes, and any group of one or more of the foregoing.

Example embodiments of the invention are applicable to any system capable of storing and handling various types of objects, in analog, digital, or other form. Although terms such as document, file, segment, block, or object may be used by way of example, the principles of the disclosure are not limited to any particular form of representing and storing data or other information. Rather, such principles are equally applicable to any object capable of representing information.

As used herein, the term ‘backup’ is intended to be broad in scope. As such, example backups in connection with which embodiments of the invention may be employed include, but are not limited to, full backups, partial backups, clones, snapshots, and incremental or differential backups.

Any of the disclosed processes, operations, methods, and/or any portion of any of these, may be performed in response to, as a result of, and/or, based upon, the performance of any preceding process(es), methods, and/or, operations. Correspondingly, performance of one or more processes, for example, may be a predicate or trigger to subsequent performance of one or more additional processes, operations, and/or methods. Thus, for example, the various processes that may make up a method may be linked together or otherwise associated with each other by way of relations such as the examples just noted. Finally, and while it is not required, the individual processes that make up the various example methods disclosed herein are, in some embodiments, performed in the specific sequence recited in those examples. In other embodiments, the individual processes that make up a disclosed method may be performed in a sequence other than the specific sequence recited.

Following are some further example embodiments of the invention. These are presented only by way of example and are not intended to limit the scope of the invention in any way.

Embodiment 1. A method comprising initiating a backup operation of data stored on a volume, determining an overwrite ratio for the backup operation based on a change log, enabling a client-side deduplication operation when the overwrite ratio is below a threshold value or disabling the client-side deduplication operation otherwise, and performing the backup operation.

Embodiment 2. The method of embodiment 1, wherein the change log comprises a bitmap for tracking changes to extents in the volume, further comprising determining the overwrite ratio based on an actual data size and a bitmap data size.

Embodiment 3. The method of embodiment 1 and/or 2, further comprising determining the actual data size, wherein the actual data size equals data written since the change log was reset.

Embodiment 4. The method of embodiment 1, 2, and/or 3, further comprising determining the bitmap data size, wherein the bitmap data size equals an extent size times a number of set bits in the change log, wherein each entry in the bitmap corresponds to an extent on the volume.

Embodiment 5. The method of embodiment 1, 2, 3, and/or 4, further comprising adjusting the actual data size based on an overwrite factor.

Embodiment 6. The method of embodiment 1, 2, 3, 4, and/or 5, wherein

${{overwrite}{ratio}} = {\frac{\left( {{actual}{data}{size}} \right)\left( \frac{100 - {{overwrite}{factor}}}{100} \right.}{{bitmap}{data}{size}}.}$

Embodiment 7. The method of embodiment 1, 2, 3, 4, 5, and/or 6, wherein the backup comprises a snapshot.

Embodiment 8. The method of embodiment 1, 2, 3, 4, 5, 6, and/or 7, wherein the overwrite factor is between 25% and 30% or between 20% and 40%.

Embodiment 9. The method of embodiment 1, 2, 3, 4, 5, 6, 7, and/or 8, further comprising deduplicating the data based on a deduplication chunk size that is different from an extent size, wherein the volume comprises a plurality of same sized extents and each extent is associated with an entry in the change log.

Embodiment 10. The method of embodiment 1, 2, 3, 4, 5, 6, 7, 8, and/or 9, further comprising resetting the actual data size each time the change log is reset, where resetting the change log includes instantiating a new change log.

Embodiment 11. A method for performing any of the operations, methods, or processes, or any portion of any of these, or any combination thereof disclosed herein.

Embodiment 12. A non-transitory storage medium having stored therein instructions that are executable by one or more hardware processors to perform operations comprising the operations of any one or more of embodiments 1 through 11.

The embodiments disclosed herein may include the use of a special purpose or general-purpose computer including various computer hardware or software modules, as discussed in greater detail below. A computer may include a processor and computer storage media carrying instructions that, when executed by the processor and/or caused to be executed by the processor, perform any one or more of the methods disclosed herein, or any part(s) of any method disclosed.

As indicated above, embodiments within the scope of the present invention also include computer storage media, which are physical media for carrying or having computer-executable instructions or data structures stored thereon. Such computer storage media may be any available physical media that may be accessed by a general purpose or special purpose computer.

By way of example, and not limitation, such computer storage media may comprise hardware storage such as solid state disk/device (SSD), RAM, ROM, EEPROM, CD-ROM, flash memory, phase-change memory (“PCM”), or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other hardware storage devices which may be used to store program code in the form of computer-executable instructions or data structures, which may be accessed and executed by a general-purpose or special-purpose computer system to implement the disclosed functionality of the invention. Combinations of the above should also be included within the scope of computer storage media. Such media are also examples of non-transitory storage media, and non-transitory storage media also embraces cloud-based storage systems and structures, although the scope of the invention is not limited to these examples of non-transitory storage media.

Computer-executable instructions comprise, for example, instructions and data which, when executed, cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. As such, some embodiments of the invention may be downloadable to one or more systems or devices, for example, from a website, mesh topology, or other source. As well, the scope of the invention embraces any hardware system or device that comprises an instance of an application that comprises the disclosed executable instructions.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts disclosed herein are disclosed as example forms of implementing the claims.

As used herein, the term ‘module’ or ‘component’ or ‘engine’ may refer to software objects or routines that execute on the computing system. The different components, modules, engines, and services described herein may be implemented as objects or processes that execute on the computing system, for example, as separate threads. While the system and methods described herein may be implemented in software, implementations in hardware or a combination of software and hardware are also possible and contemplated. In the present disclosure, a ‘computing entity’ may be any computing system as previously defined herein, or any module or combination of modules running on a computing system.

In at least some instances, a hardware processor is provided that is operable to carry out executable instructions for performing a method or process, such as the methods and processes disclosed herein. The hardware processor may or may not comprise an element of other hardware, such as the computing devices and systems disclosed herein.

In terms of computing environments, embodiments of the invention may be performed in client-server environments, whether network or local environments, or in any other suitable environment. Suitable operating environments for at least some embodiments of the invention include cloud computing environments where one or more of a client, server, or other machine may reside and operate in a cloud environment.

With reference briefly now to FIG. 7 , any one or more of the entities disclosed, or implied, by the Figures and/or elsewhere herein, may take the form of, or include, or be implemented on, or hosted by, a physical computing device, one example of which is denoted at 700. As well, where any of the aforementioned elements comprise or consist of a virtual machine (VM), that VM may constitute a virtualization of any combination of the physical components disclosed in FIG. 7 .

In the example of FIG. 7 , the physical computing device 700 includes a memory 702 which may include one, some, or all, of random access memory (RAM), non-volatile memory (NVM) 704 such as NVRAM for example, read-only memory (ROM), and persistent memory, one or more hardware processors 706, non-transitory storage media 708, UI device 710, and data storage 712. One or more of the memory components 702 of the physical computing device 700 may take the form of solid state device (SSD) storage. As well, one or more applications 714 may be provided that comprise instructions executable by one or more hardware processors 706 to perform any of the operations, or portions thereof, disclosed herein.

Such executable instructions may take various forms including, for example, instructions executable to perform any method or portion thereof disclosed herein, and/or executable by/at any of a storage site, whether on-premises at an enterprise, or a cloud computing site, client, datacenter, data protection site including a cloud storage site, or backup server, to perform any of the functions disclosed herein. As well, such instructions may be executable to perform any of the other operations and methods, and any portions thereof, disclosed herein.

The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope. 

What is claimed is:
 1. A method, comprising: initiating a backup operation of data stored on a volume; determining an overwrite ratio for the backup operation based on a change log; enabling a client-side deduplication operation when the overwrite ratio is below a threshold value or disabling the client-side deduplication operation otherwise; and performing the backup operation.
 2. The method of claim 1, wherein the change log comprises a bitmap for tracking changes to extents in the volume, further comprising determining the overwrite ratio based on an actual data size and a bitmap data size.
 3. The method of claim 2, further comprising determining the actual data size, wherein the actual data size equals data written since the change log was reset.
 4. The method of claim 3, further comprising determining the bitmap data size, wherein the bitmap data size equals an extent size times a number of set bits in the change log, wherein each entry in the bitmap corresponds to an extent on the volume.
 5. The method of claim 4, further comprising adjusting the actual data size based on an overwrite factor.
 6. The method of claim 5, wherein the ${{overwrite}{ratio}} = {\frac{\left( {{actual}{data}{size}} \right)\frac{\left( {100 - {{overwrite}{factor}}} \right)}{100}}{{bitmap}{data}{size}}.}$
 7. The method of claim 6, wherein the backup comprises a snapshot.
 8. The method of claim 6, wherein the overwrite factor is between 25% and 30% or between 20% and 40%.
 9. The method of claim 1 further comprising deduplicating the data based on a deduplication chunk size that is different from an extent size, wherein the volume comprises a plurality of same sized extents and each extent is associated with an entry in the change log.
 10. The method of claim 9, further comprising resetting the actual data size each time the change log is reset, where resetting the change log includes instantiating a new change log.
 11. A non-transitory storage medium having stored therein instructions that are executable by one or more hardware processors to perform operations comprising: initiating a backup operation of data stored on a volume; determining an overwrite ratio for the backup operation based on a change log; enabling a client-side deduplication operation when the overwrite ratio is below a threshold value or disabling the client-side deduplication operation otherwise; and performing the backup operation.
 12. The non-transitory storage medium of claim 11, wherein the change log includes a bitmap for tracking changes to extents in the volume, further comprising determining the overwrite ratio based on an actual data size and a bitmap data size.
 13. The non-transitory storage medium of claim 12, further comprising determining the actual data size, wherein the actual data size equals data written since the change log was reset.
 14. The non-transitory storage medium of claim 13, further comprising determining the bitmap data size, wherein the bitmap data size equals an extent size times a number of set bits in the change log, wherein each entry in the bitmap corresponds to an extent on the volume.
 15. The non-transitory storage medium of claim 14, further comprising adjusting the actual data size based on an overwrite factor.
 16. The non-transitory storage medium of claim 15, wherein the ${{overwrite}{ratio}} = {\frac{\left( {{actual}{data}{size}} \right)\frac{\left( {100 - {{overwrite}{factor}}} \right)}{100}}{{bitmap}{data}{size}}.}$
 17. The non-transitory storage medium of claim 16, wherein the backup comprises a snapshot.
 18. The non-transitory storage medium of claim 16, wherein the overwrite factor is between 25% and 30% or between 20% and 40%.
 19. The non-transitory storage medium of claim 11, further comprising deduplicating the data based on a deduplication chunk size that is different from an extent size, wherein the volume comprises a plurality of same sized extents and each extent is associated with an entry in the change log.
 20. The non-transitory storage medium of claim 19, further comprising resetting the actual data size each time the change log is reset, where resetting the change log includes instantiating a new change log. 